import java.io.PrintStream;
import java.sql.SQLOutput;

public class HelloBit {
    public static void main1(String[] args) {
        //java的基本数据类型 字节byte 短整型short 整型int 长整型long
        //float  单精度浮点型  double双精度浮点型
        //char 字符型 boolean 布尔类型
        //bit-》 byte-》 Kb-》 Mb-》 Gb-》 Tb-》 Pb

        //四个字节 32位 Java中，没有所谓的无符号，有符号的概念
        //整型直接表示负数和整数 看符号位  (-2^31-2^31-1)
        int a=10;
        System.out.println(a);
        //包装类  integer就是int的plus版本（加大版本/包装类）
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);



    }
//数据类型多的原因，满足不同情景下的需要
    public static void main2(String[] args) {
        byte a=100;
        System.out.println(a);
        System.out.println(Byte.MAX_VALUE);
        System.out.println(Byte.MIN_VALUE);

    }
    //无论在几位系统中，int和long的大小都是确定的，不会受系统的影响-》可移植性
    public static void main3(String[] args) {
        //八个字节  64比特   -2^63--2^63-1
        //长整型变量的初始值在后面加L或者l，推荐加L
        //
        long a=100L;
        System.out.println(Long.MAX_VALUE);
        System.out.println(Long.MIN_VALUE);
    }

    public static void main4(String[] args) {
        //两个字节  -2^15-2^15-1
        //如果给定的值超过了变量所能表示的最大值，那么直接报错，无法运行
        //java的安全性
        short sh=1000;
        System.out.println(sh);
        System.out.println(Short.MAX_VALUE);
        System.out.println(Short.MIN_VALUE);
    }

    public static void main5(String[] args) {
        //一次编译，到处运行
        //安全性
        //可移植性
        //-2^7-2^7-1   -128-127
        byte b=6;
        System.out.println(b);
        System.out.println(Byte.MIN_VALUE);
        System.out.println(Byte.MAX_VALUE);
    }

    //一个类里面只能有一个主函数
    //一个项目只能有一个public类，且public类的名字要和文件名相同。
    // 但是一个类里面可以有多个public方法，但是只能有一个main

    public static void main7(String[] args) {
        //八个字节  在输出的时候，会将小数点后面的0忽略掉
        double d=10.0;
        System.out.printf("%f\n", d);
        System.out.println(d);
        System.out.printf("%.2f", d);

       /* double d1=10.00;
        System.out.println(d1);
        //System.out.printf("%.2lf",d1);
        int a=10;
        int b=4;
        System.out.println(a/b);*/
        //除号两边都是整数，按照整数除法计算，如果要得出小数结果，则需要左右变量
        // 有一个或两个小数
        //注释快捷键 ctrl shift /

        double num=1.1;
        System.out.println(num*num);
        System.out.println(num);
        //小数没有精确的，只能说精确到某一位上
        //PDD 砍一刀 99.99% 小数后面没有精确的，还有很多位，但是只能显示两位小数

    }

    public static void main8(String[] args) {
        //小数常量默认是double，直接赋值给float时会报错，需要进行类型转换
        float f=12.5f;
        System.out.println(f);
        System.out.println(Float.MAX_VALUE);
        System.out.println(Float.MIN_VALUE);
        //包装类九三基本数据类型对应的类类型，是基本数据类型的加大版本，具备的功能比较多。有
        // 了她可以提供很多的方法供我们使用、只需要每个基本数据类型的包装类是什么就好。




    }

    public static void main9(String[] args) {
        char ch='w';
        char ch2='美';
        char ch3='羊';
        char ch4='羊';
        char ch5=97;
        System.out.println(ch2);
        System.out.println(ch);
        System.out.println(ch3);
        System.out.println(ch4);
        System.out.println(ch5);
        //一个字节时 ASCII码字符集
        //两个字节时 Unicode字符集
        //字符集和编码方法  编码方法：就是如何编码 不同字符集之间同一个元素的编码方法
        // 可能不一样，此时可能会出现乱码
    }

    public static void main10(String[] args) {
        //没有明确的大小
        boolean flag=true;
        System.out.println(flag);
        System.out.println(Boolean.FALSE);
        //C语言中，0是假，非0即是真，但是在Java中真值只有true，假只有false
    }
    //C缺陷和陷阱
    //类型转换
    //Java作为一个强类型编程语言，当不同类型之间的变量相互赋值的时候，会有较严格的校验
    //Java的类型转换分为 自动类型转换（隐式类型转换）  强制类型转换

    public static void main11(String[] args) {
        int a = 10;
        long b = 20L;
        a = (int) b;
        //int表示的数据范围更小，比long小，所以不能将一个大范围数赋值给小范围数
        //float表示的数据宽度更大，int表示的数据宽度比float小，float赋值给int-》 ok，相同则不可以

        int c = 100;
        double f1 = 12.3;
        //f1 = c;
        c=(int)f1;
        System.out.println(c);
        System.out.println(f1);
        //将大范围赋值给小范围，可能会发生精度丢失
        //进行类型转换时，只有相关类型的才可以相互转换
        //boolean和其他类型不能相互转换

        //类型提升
        //不同类型的数据混合运算。类型范围小的提升为类型范围大的。
        // 对于short，byte这些比四个字节小的类型，会先提升为4个字节的int，再运算
        int e=0;
        long f=20;
        // int d=e+f;
        //e会发生整型提升，和f相加得到的值是long类型。d是int，不能接受
        byte r=1;
        byte t=10;
        //byte u=1000;  超范围报错
        //字面常量赋值给字节类型为什么没报错？
        // 因为编译器会自动检查，如果字面值的范围是在自己表示的范围内，就不会报错
        //byte i=r+t;
        //byte小于四个字节，在运算时自动提升为整型进行运算，字节类型无法赋值给byte
    }

    public static void main13(String[] args) {
        //回顾：八种基本数据类型
        //整型：字节byte-》Byte 短整型short-》Short 整型int-》Integer 长整型long-》Long
        //浮点型  单精度float 双精度double
        //字符型 char
        //布尔型 boolean
        //对应的包装类，除了int，其他都是首字母大写


        //在Java中，直接赋值不能超过这个数据类型所能表示的最大范围
        //boolean数据类型只有两个值，false和true，不存在1是真，0是假的情况

        //类型转换 隐式转换  显式转换（强转）
        //类型提升

        //字符串
        //在C语言中，没有字符串类型。只有字符数组
        //char *p="hello"; 此时的p仅仅是一个指针变量
        //在Java中，有了全新的数据类型string
        String str="hello";
        System.out.println(str);
        int a=10;
        System.out.println(a);
        //在Java中，没有指针，取不到a的地址，无法通过地址去改变数据的值（Java偏上层）
        //str和a都是局部变量，存放在栈上
        //string存储的是str的地址
        //在Java中，没有所谓的字符串为\0截至




    }

    public static void main14(String[] args) {
        String str1="hello";
        String str2="world";
        System.out.println(str1+str2);
        //在Java中，如果两个字符串进行相加，那么他的意思就是拼接的意思
        int a=10;
        int b=20;
        System.out.println("a="+a);
        System.out.println("b="+b);
        //字符串加其他数据类型，输出的是字符串  字符串+其他类型-》字符串
        System.out.println("a+b="+a+b);
        //（a+b=10）20  a+b=1020
        System.out.println("a+b="+(a+b));
        //a+b=30
        System.out.println(a+b+"是a+b的和");
        //30是a+b的和
        //从左向右依次运行
        //String没有包装类，本身就是类
        //包装类-》基本数据类型对应的类类型

        //基本数据类型 （int byte） 引用数据类型（String Byte 数组 接口）
    }

    public static void main15(String[] args) {
        //需求 int-》String
        int a=12345;

        String ret=String.valueOf(a);
        String ret1=String.valueOf(12.3);
        System.out.println(ret);
        System.out.println(""+a);
        System.out.println(ret1);
        String aa=a+"";
        System.out.println(aa);

        //String ->int
        //通过点号 来调用类中的方法
        String ret3="12345";
        int num1=Integer.valueOf(ret3);
        int num3=Integer.parseInt(ret3);
        System.out.println(num1+1);
        String ret4="1.24";
        double num2=Double.valueOf(ret4);
        double num4=Double.parseDouble(ret4);
        System.out.println(num2+0.1);

        //parseInt和valueof作用相同->将字符串··和其他基本数据类型进行转换
    }
//
//    public static void main16(String[] args) {
//        //基本类型中没有方法，类中才有方法
//        //运算符 变量与变量之间-》运算符
//        //  变量和运算符的结合-》表达式
//        //逻辑控制 选择 循环
//
//        // 算数运算符  加减乘除模
//        int a=20;
//        int b=40;
//        System.out.println(5/2);          //2
//        System.out.println((float)5/2);   //2.5
//        System.out.println(5/(float)2);   //2.5
//        System.out.println((float)(5/2)); //2.0
//
//        System.out.println(10%3);    //1    3*3=1
//        System.out.println(10%-3);   //1   （-3*-3）+1
//        System.out.println(-10%3);   //-1  （3*-3）+（-1）
//        System.out.println(-10%-3);  //-1  （-3*3）+（-1）
//
//
//        System.out.println(11.1%2);
//        //C语言取模两边必须都为整数，但是Java中是允许的，但是没有什么意思
//
//
//    }
//
//    public static void main18(String[] args) {
//        //增量运算符（赋值运算符）
//        int a=10;
//        int b=20;
//        System.out.println(a+=b);
//        short sh=2;
//        //sh=sh+2;
//        //sh是short，接收不了整型，除非强制转换
//        sh+=2;
//        //复合运算符可以理解为自动帮助我进行类型转换，
//        byte aa=100;
//        aa+=200;
//        System.out.println(aa);
//        System.out.println(sh);
//
//        //自增自减
//        int a1=10;
//        a++;
//        System.out.println(a);
//        int b1=++a;
//        System.out.println(a);
//        System.out.println(b);
//
//    }
//
//    public static void main19(String[] args) {
//
//        int i=10;
//        i=i++;
//        System.out.println(i);//只需要记住结果就好，不需要了解-》10
//
//        //关系运算符
//        System.out.println(1<5);
//        System.out.println(1<=5);
//        System.out.println(1>5);
//        System.out.println(1>=5);
//        System.out.println(1==5);
//        System.out.println(1!=5);
//
//        int a=1;
//        int b=2;
//        System.out.println((a==1)&&(b==2));
//        System.out.println((a!=1)&&(b==2));
//        //System.out.println(1/0);
//        System.out.println(a==2 && (1/0)==0);
//        //不会报错，因为短路了
//        //异常  算数异常  有时候在报错中不会出现原因，只会提醒异常类型（1：40分钟处），但是
//        //在后面会显示异常的代码位置
//        //System.out.println(3<a<100);
//        //3<a 的结果是boolean值，Boolean不能和int比较，编译失败
//
//
//        //逻辑运算符  并且 或者 非
//        //布尔表达式1 && 布尔表达式2  （短路与）
//        // 特点：表达式1为真，则执行表达式2，表达式2也为真，整个表达式为真
//        //如果表达式1为假2，则不执行表达式2，整个表达式结果为假
//
//        //布尔表达式1 || 布尔表达式2
//        //特点 :表达式1为假，则执行表达式2，表达式2也为假，则整个表达式为假
//        //表达式1为真，则不执行表达式2，整个表达式结果为真
//        System.out.println(a==1 || b==2);
//        System.out.println(a==1 || (1/0)==0);
//
//
//        //！布尔表达式
//        //表达式的结果能是true或者是false
//
//        //短路求值
//        //&和 |
//        //此时&，如果左右两边都是布尔类型，也相当于逻辑运算，但是&不会短路，&&如果第一个为假，，则短路
//        //&如果第一个为假，不会短路，会继续执行布尔表达式2
//        System.out.println(a==1 & b==2);
//
//        //&和| 如果表达式结果为boolean时，也表示逻辑运算，但是和&7和||相对比，他们不支持短路求值
//
//
//    }
//
//    public static void main20(String[] args) {
//        //位运算符
//        // &按位与  与的是二进制位 对应的二进制位全为1才为1
//        //0000 1101
//        //0000 1011
//        //0000 1001
//        // | 按位或 或的是二进制位 对应的二进制位全为0才为0
//        //0000 1101
//        //0000 1011
//        //0000 1111
//
//        //按位异或 ^  异或的是二进制位，对应位不一样就是1（找不同）
//        //特点：两个相同的数字异或，结果为0，0异或谁都得它自身
//        //0000 1101
//        //0000 1011
//        //0000 0110
//
//        //按位取反 ~  将对应二进制位取反 0变1，1变0
//        int a=10;
//        System.out.println(~a);
//
//        //移位运算符
//        //<< 左移  左移补0
//        // >>右移  右移是补符号位(整数补0，负数补1)-1是个例外，怎么移都是-1
//        // >>> 无符号右移  统统在左边补0
//        //00010110   22
//        //00101100   44
//        //01011000   88
//
//        //0000 1010
//        //0000 0101
//        //1111 1111
//        //1111 1111
//        //-1不论怎么移位都是-1
//
//        int aa=-1;
//        System.out.println(aa>>2);
//        System.out.println(aa>>>30);
//
//        //条件运算符 表达式1？表达式2：表达式3
//        //表达式1一定是布尔表达式，表达式1为真，返回表达式2，否则返回表达式3
//        System.out.println((a==1)?(a=1):(a=2));
//        System.out.println(a=3);
//
//        //条件表达式可以嵌套使用
//    }
//
//    public static void main23(String[] args) {
//        System.out.println((true==true)?(true==true)?false:true:true);
//        //运算符的优先级
//
//        System.out.println("坚持-》学习一定要坚持！");
//        System.out.println("尽量跟上直播，录播是迫不得已！");
//
//
//    }
//
////    public static void main21(String[] args) {
////
////        int a = 10;
////
////        if(a > 0) {
////            System.out.println("正数");
////        }
////        else if (a < 0){
////            System.out.println("负数");
////        }
////        else {
////            System.out.println("零");
////        }
////        if(a > 10) {
////            System.out.println("大于10");
////        }
////        //普通闰年 四的倍数不是一百的倍数
////        //世纪闰年 必须是四百的倍数
////        int year = 2022;
////        if(year % 100 == 0) {
////            if (year % 400 == 0) {
////                System.out.println("Yes");
////            } else {
////                System.out.println(NO);
////                }
////
////        }else {
////                if(year % 4 == 0) {
////                    System.out.println(Yes);
////                }
////
////            }
////
////        if(year%100 == 0 && year%400 == 0 || year % ) {
////
////
////        }else {
////
////        }
////
////
////
////    }
////
////
////    public static void main22(String[] args) {
////        //悬垂else -》else 和离它最近的if匹配
////        int x = 10;
////        int y = 20;
////        if(x == 20) {
////            System.out.println("aaa");
////        }
////        else {
////            System.out.println("bbb");
////        }
////
////        if(a > 0)
////            if(b > 0)
////                System.out.println("aaa");
////        else
////                System.out.println("bbbb");
////
////        int i = 0;
////        switch (i) {
////            case 1:
////                System.out.println("111");
////                break;
////            case 2:
////                System.out.println("2222");
////                break;
////            case 3:
////                System.out.println("3333");
////                break;
////            default:
////                System.out.println("wrong");
////                break;
////        }
////
////    }
////
////    public static void main24(String[] args) {
////        //不能做switch的参数的数据类型是什么 -》浮点型 长整型 布尔
////        //long double float  boolean
////        //字符串和字符可以
////        String a= "abc";
////        switch(a){
////            case "haha":
////            case "hehe":
////            default:
////        }
////        //多个case后的常量值不能重复 ，break不要遗漏
////        //switch不能表示复杂的条件，switch支持嵌套
////        //多分支选择-》 switch 复杂条件-》 if
////
////    }
//
//    //循环 while for do_while 重复的做某件事
//    public static void main(String[] args) {
//        int a = 1;
//        // while (布尔表达式) {}
//        while (a <= 5) {
//            System.out.println("hello");
//            //必须有改变循环条件的语句，不能可能死循环
//            a++;
//        }
//    }
//
//    //调试  打断点 在需要的行点一下
//    //蓝色 即将执行还没执行
//    //弯腰箭头 跳过函数 （第一个）
//
//    //直箭头
//}






